package com.gimi.cloud.jimi.dao.myMapper.core.query;


import com.gimi.cloud.jimi.dto.sys.SysMenuDTO;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

public class QueryParam {
	private String sql;
	private Map<String,Object> params = new HashMap();
	private Object paramObject;
	/*
	private Integer pageSize;
	private Integer page;
	*/

	public String getSql() throws Exception{
		if(paramObject!=null){
			params = objectToMap(paramObject);
		}
		sql = handleSql(new StringBuffer(sql),params);
		sql = valueSql(sql,params);
		return sql;
	}

	public void setSql(String sql) {
		this.sql = sql;
	}

	public Map getParams() {
		return params;
	}

	public void setParams(Map<String,Object> params) {
		this.params = params;
	}

	public Object getParamObject() {
		return paramObject;
	}

	public void setParamObject(Object paramObject) {
		this.paramObject = paramObject;
	}

	/*
	public Integer getPageSize() {
		return pageSize;
	}

	public void setPageSize(Integer pageSize) {
		this.pageSize = pageSize;
	}

	public Integer getPage() {
		return page;
	}

	public void setPage(Integer page) {
		this.page = page;
	}
	*/

	/**
	 * 把实体对象转化成Map
	 * @param paramObject
	 * @return
	 */
	public Map<String,Object> objectToMap(Object paramObject) throws Exception{
		Map<String,Object> map = new HashMap<String, Object>();
		Class clazz = paramObject.getClass();
		while (clazz!=null){
			for (Field field : Arrays.asList(clazz.getDeclaredFields())) {
				if(!field.getName().toLowerCase().equals("serialversionuid")) {
					PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
					Method method = descriptor.getReadMethod();
					if(null!=method.invoke(paramObject)) {
						map.put(field.getName().toLowerCase().toString(), method.invoke(paramObject));
					}
				}
			}
			clazz = clazz.getSuperclass();
		}
		return map;
	}

	/**
	 * sql值处理
	 * @param sql
	 * @param params
	 * @return
	 */
	public String valueSql(String sql,Map<String,Object> params){
		sql = sql.toLowerCase();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for (Map.Entry<String, Object> entry : params.entrySet()) {
			String key = ":"+entry.getKey().toLowerCase();
			Object value = entry.getValue();
			//处理sql中模糊查询条件,  替换 '%' || :xxx || '%' 
			String regEx = "\\'%\\'\\s*\\|\\|\\s*"+key+"\\s*\\|\\|\\s*\\'%\\'";
			sql = sql.replaceAll(regEx,"'%"+value.toString()+"%'");
			switch (value.getClass().getName()){
				case "java.lang.String":
					sql = sql.replaceAll(key,"'"+value+"'");
					break;
				case "java.lang.Float":
					sql = sql.replaceAll(key,value.toString());
					break;
				case "java.lang.Integer":
					sql = sql.replaceAll(key,value.toString());
					break;
				case "java.lang.Double":
					sql = sql.replaceAll(key,value.toString());
					break;
				case "java.util.Date":
					sql = sql.replaceAll(key,"'"+df.format(value)+"'");
					break;
				case "java.lang.Long":
					sql = sql.replaceAll(key,value.toString());
					break;
				case "java.lang.Boolean":
					sql = sql.replaceAll(key,(Boolean)value?"1":"0");
					break;
				default:
					sql = sql.replaceAll(key,"'"+value+"'");
					break;
			}
		}
		return sql;
	}

	/**
	 * sql处理函数
	 * @param sql
	 * @param parms
	 * @return
	 */
	public String handleSql(StringBuffer sql, Map<String,Object> parms){
		sql=SbreplaceAll(sql," AND "," and ");
		sql=SbreplaceAll(sql,")AND ",")and ");
		sql=SbreplaceAll(sql," AND("," and(");
		sql=SbreplaceAll(sql,")AND(",")and(");
		sql=SbreplaceAll(sql," OR "," or ");
		sql=SbreplaceAll(sql,")OR ",")or ");
		sql=SbreplaceAll(sql," OR("," or(");
		sql=SbreplaceAll(sql,")OR(",")or(");
		sql=SbreplaceAll(sql," LIKE "," like ");

		//去除特殊字符
		if(sql.indexOf("\t")>-1){
			String _str=sql.toString().replaceAll("\t","");
			sql.delete(0, sql.length());
			sql.append(_str);
		}
		if(sql.indexOf("\n")>-1){
			String _str=sql.toString().replaceAll("\n","");
			sql.delete(0, sql.length());
			sql.append(_str);
		}
		if(sql.indexOf("\r")>-1){
			String _str=sql.toString().replaceAll("\r","");
			sql.delete(0, sql.length());
			sql.append(_str);
		}
		if(parms==null){
			parms=new HashMap();
		}

		//首先找出sql中所有的key，然后再和map中的key进行比较
		Map<String,String> keysmap = finedSqlKey(sql);
		List<String> removelist = new ArrayList();
		Iterator keyit = parms.keySet().iterator();
		//传入的map的key必须与当前sql匹配否则抛出错误
		while(keyit.hasNext()){
			//如果当前传入的参数里面的值为null则直接删除参数
			String _key1=keyit.next().toString();
			Object o=parms.get(_key1);
			if(o==null || ( o instanceof String && parms.get(_key1).equals(""))){
				removelist.add(_key1);
				continue;
			}
			String key=":"+_key1.toLowerCase();

			if(!keysmap.containsKey(key)){
//	  			throw new Exception("传入的参数:"+key+"不匹配!");
				//调整为删除多余的参数
//	  			parms.remove(key);
				removelist.add(_key1);
			}else{
				//如果能够匹配则删除sql里面的keymap
				keysmap.remove(key);
			}
		}
		for(String sk:removelist){
			parms.remove(sk);
		}
		Iterator removeit = keysmap.keySet().iterator();
		//循环剩余的sqlKeyMap,并删除sql语句对应的key
		while(removeit.hasNext()){
			String key=removeit.next().toString();
			deleteSqlByKey(sql,key);
		}
		return sql.toString();
	}


	/**
	 * 关键字过滤
	 * @param sb
	 * @param oldStr
	 * @param newStr
	 * @return
	 */
	public StringBuffer SbreplaceAll(StringBuffer sb,String oldStr, String newStr){
		int i = sb.indexOf(oldStr);
		int oldLen = oldStr.length();
		int newLen = newStr.length();
		while (i > -1) {
			sb.delete(i, i + oldLen);
			sb.insert(i, newStr);
			i = sb.indexOf(oldStr, i + newLen);
		}
		return sb;
	}

	/**
	 * 通过sql语句找出当前有哪些参数并返回一个KeyMap<br>
	 * 在找keys的过程中，自动将key的值全部转换为小写
	 * @param sql
	 * @return
	 */
	private Map<String,String> finedSqlKey(StringBuffer sql){
		Map<String ,String> keymap=new HashMap<String, String>();
		int indexnew=0;
		indexnew=sql.indexOf(":",indexnew)+1;
		int dealkeyindex_s=0;
		int dealkeyindex_e=0;
		StringBuffer keysql=new StringBuffer();
		while(indexnew>0){
			keysql.delete(0, keysql.length());
			dealkeyindex_s=indexnew;
			while (indexnew<=sql.length()-1 &&
					(Character.isDigit(sql.charAt(indexnew))
							||Character.isLetter(sql.charAt(indexnew))
							|| sql.charAt(indexnew)=='_') ) {
				keysql.append(sql.charAt(indexnew));
				indexnew++;

			}

			dealkeyindex_e=indexnew;
			indexnew=sql.indexOf(":",indexnew)+1;
			keymap.put(":"+keysql.toString().toLowerCase(), "");
			//处理sqlBuffer中的key，直接变成小写
			sql.delete(dealkeyindex_s, dealkeyindex_e);
			sql.insert(dealkeyindex_s,keysql.toString().toLowerCase());
		}
		return keymap;
	}

	/**
	 * 删除sql里面的查询条件 xxx  = :xxx
	 * @param sql
	 * @param key
	 */
	private void deleteSqlByKey(StringBuffer sql,String key){
		int l_brackets =0;
		int r_brackets =0;

		//首先找到key所在位置，然后倒序删除sql
		int index=sql.indexOf(key);
		//取当前key后面的一个值，如果是数字或者字符则说明没有匹配到key,需要进行下一次匹配
		//可能出现 :aa  :aa2的情况 在删除:aa的时候会同时删除 :aa2
		boolean finedafterchar=false;
		int afterindex=index+key.length();
		//如果index超出了范围则说明后面没有值了
		if(afterindex>=sql.length()){
			finedafterchar=true;
		}

		String sqlstr="";
		String sqlstr2="";
		while(!finedafterchar){
			//如果当前afterindex的值是a-z则说明 出现了 :aa :aa2的情况，需要立即进行下一匹配
			char afterchar=sql.charAt(afterindex);
			if((afterchar <= 'Z' && afterchar >= 'A')
					|| (afterchar <= 'z' && afterchar >= 'a')
					|| (afterchar <= '9' && afterchar >= '0')
					|| afterchar=='.'||afterchar=='_'||afterchar=='-'
					){
				//没有找到需要进行下一次匹配
				index=sql.indexOf(key,index+1);
				afterindex=index+key.length();
				//如果仍然没有找到则直接退出
				if(index==-1){
					return;
				}else{
					continue;
				}
			}else{
				finedafterchar=true;
			}
		}
		if(index>-1){
			//首先删除key
			//2015-12-5尧义增加了 and t.aaa like '%'||:aaa||'%' and的判断,如果只删除了:aaa则后面的||'%'没有被删除
			//and t.aaa like '%'||:aaa||'%' )and
			//如果当前的 :key后面有|| 'xxx'
			if(sql.substring(index+key.length()).trim().startsWith("||")){
				//删除后面的空格
				while(sql.charAt(index+key.length())==' '){
					sql.deleteCharAt(index+key.length());
				}
				//删除||
				//删除两次
				sql.deleteCharAt(index+key.length());
				sql.deleteCharAt(index+key.length());
				//删除||后面的空格
				while(sql.charAt(index+key.length())==' '){
					sql.deleteCharAt(index+key.length());
				}
				//找到后面的'xxx' 或者 fun()并删除
				//找到后面的括号
				int _bracket_after=finebracketIndex(sql,index+key.length(),1);
				if(_bracket_after!=-1){
					//index 位置 在 )后面 所以为了避免把)也删除了需要再向前找到)的开始位置

					int _bracket_after1=sql.substring(0, _bracket_after).lastIndexOf(")");
					if(index+key.length()<_bracket_after1){
						_bracket_after=_bracket_after1;
					}
				}
				//找到后面的and 或者 or
				int _andorindex=finedandorIndex(sql,index+key.length(),1);
				if(_andorindex!=-1){
					//index 位置 在 and后面 所以为了避免把and也删除了需要再向前找到and的开始位置
					int _andorindex1=sql.substring(0, _andorindex).lastIndexOf(" and ");
					int _andorindex2=sql.substring(0, _andorindex).lastIndexOf(" or ");
					if(_andorindex1!=-1){
						_andorindex=_andorindex1;
					}
					if(_andorindex2!=-1){
						_andorindex=_andorindex2;
					}
					if(_andorindex1!=-1 && _andorindex2!=-1){
						_andorindex=_andorindex1>_andorindex2?_andorindex1:_andorindex2;
					}
				}
				//哪个小选哪个
				int _delindex=-1;
				//排除掉-1的情况
				if(_bracket_after!=-1 && _andorindex!=-1){
					_delindex=_bracket_after>_andorindex?_andorindex:_bracket_after;
				}
				if(_bracket_after==-1 && _andorindex!=-1){
					_delindex=_andorindex;
				}
				if(_bracket_after!=-1 && _andorindex==-1){
					//index位置在)后面为了避免把 )也删除了所以需要再向前找到)的位置
					_delindex=_bracket_after;
				}
				if(_delindex!=-1){
					//删除前需要增加一个空格
					sql.insert(_delindex, ' ');
					sql.delete(index+key.length(), _delindex);
				}else{
					//如果后面没有找到and或者)则说明后面是'xxx'直接找到第二个'然后删除
					int _delindex2=sql.substring(index+key.length()).indexOf("'");
					//删除第一个'然后找到第二个再删
					sql.delete(index+key.length(), index+key.length()+_delindex2+1);
					_delindex2=sql.substring(index+key.length()).indexOf("'");
					sql.delete(index+key.length(), index+key.length()+_delindex2+1);
				}


			}
			if(sql.substring(0,index).trim().endsWith("||")){
				int _delindex=-1;
				//删除前面的空格
				while(sql.charAt(index+_delindex)==' '){
					sql.deleteCharAt(index+_delindex);
					_delindex--;
				}
				//删除||
				//删除两次
				sql.deleteCharAt(index+_delindex);
				_delindex--;
				sql.deleteCharAt(index+_delindex);
				_delindex--;
				//删除||前面的空格
				while(sql.charAt(index+_delindex)==' '){
					sql.deleteCharAt(index+_delindex);
					_delindex--;
				}
				//找到前面的'xxx' 或者 fun()并删除 应该在= 或者 != 或者 not like 或者 like后面
				//先删除第一个'
				sql.deleteCharAt(index+_delindex);
				//然后找到前面的第一个'并删除
				int _delindex2=sql.substring(0, index+_delindex).lastIndexOf("'");
				if(_delindex2!=-1){
					sql.delete( _delindex2,index+_delindex);
				}
				//重定位index
				index=_delindex2;

			}
			sql.delete(index, index+key.length());
			index--;
			//然后再删除key前面的xxx  =
			//是否已经找到=符合
			boolean hasfinedequal=false;
			//是否已经找到=符号前面的字母
			boolean hasfinedcharacter=false;
			//为了避免死循环，所以循环次数不能大于字段长度
			int whileindex=0;
			int sqllength=sql.length();
			while(index>-1 && whileindex<=sqllength+1){
				whileindex++;
				//操作符包含 = != <> > < >= <= in not in
				char sqlchar=sql.charAt(index);
				if(sqlchar=='\t' || sqlchar=='\n'){
					sql.delete(index, index+1);
					index--;
				}
				//判断当前操作符是否是like 或者not like
				if((index==sql.length()-1 && sql.charAt(index)=='e' && sql.charAt(index-1)=='k' &&  sql.charAt(index-2)=='i' && sql.charAt(index-3)=='l')
						|| (index+1<sql.length() && index >2 &&  sql.charAt(index-4)==' ' && (sql.charAt(index+1)==' ' || sql.charAt(index+1)=='(' )
						&& (sql.charAt(index)=='e' && sql.charAt(index-1)=='k' &&  sql.charAt(index-2)=='i' && sql.charAt(index-3)=='l' ))){
					hasfinedequal=true;//表示已找到操作符
					//判断前面是否有not
					if(index>15 ){
						//当前index位置在 e的位置 前面是lik 所以截取字段的时候需要-3
						sqlstr2=sql.substring(index-10, index-3);
						String _sqlstr2=sqlstr2.trim();
						int endnotindex=sqlstr2.lastIndexOf("not");
						//循环向前截取10个字符并且去掉空格后，如果以not结尾则说明是not like
						if(_sqlstr2.endsWith("not") && endnotindex>-1){
							int notindex=index-(sqlstr2.length()-endnotindex)-3;
							sql.delete(notindex, index+1);
							index=notindex;
							while(index>sql.length()-1 ){
								index--;
							}
							//找到当前index之前的第一个字符并修改index的位置
							while( sql.charAt(index)==' '){
								sql.delete(index, index+1);
								index--;
							}
							continue;
						}
					}
					//因为like有四个字符所以需要连续删除两个字符
					sql.delete(index-3, index+1);
					index=index-4;
					//找到当前index之前的第一个字符并修改index的位置
					while(sql.charAt(index)==' '){
						sql.delete(index, index+1);
						index--;
					}
					continue;
				}
				//首先需要判断是否in 或者 not in
				//或者sql结尾就是in
				else if((index==sql.length()-1 && sqlchar=='n' && sql.charAt(index-1)=='i') ||  (index+1<sql.length() && index >2 &&  sql.charAt(index-2)==' ' && (sql.charAt(index+1)==' ' || sql.charAt(index+1)=='(' )
						&& (sqlchar=='n' && sql.charAt(index-1)=='i' ))
						){
					hasfinedequal=true;//表示已找到操作符
					//判断前面是否有not
					if(index>15 ){
						//当前index位置在 n的位置 前面是i 所以截取字段的时候需要-1
						sqlstr2=sql.substring(index-10, index-1);
						String _sqlstr2=sqlstr2.trim();
						int endnotindex=sqlstr2.lastIndexOf("not");
						//循环向前截取10个字符并且去掉空格后，如果以not结尾则说明是not in
						if(_sqlstr2.endsWith("not") && endnotindex>-1){
							int notindex=index-(sqlstr2.length()-endnotindex)-1;
							sql.delete(notindex, index+1);
							index=notindex;
							//找到当前index之前的第一个字符并修改index的位置
							while(sql.charAt(index)==' '){
								sql.delete(index, index+1);
								index--;
							}
							continue;
						}
					}
					//因为in有两个字符所以需要连续删除两个字符
					sql.delete(index-1, index+1);
					index=index-2;
					//找到当前index之前的第一个字符并修改index的位置
					while(sql.charAt(index)==' '){
						sql.delete(index, index+1);
						index--;
					}
					continue;

				}

				if((sql.charAt(index) <= 'Z' && sql.charAt(index) >= 'A')
						|| (sql.charAt(index) <= 'z' && sql.charAt(index) >= 'a')
						|| (sql.charAt(index) <= '9' && sql.charAt(index) >= '0')
						|| sql.charAt(index)=='.'||sql.charAt(index)=='_'||sql.charAt(index)==',' ||sql.charAt(index)=='-'||sql.charAt(index)=='\''
						){
					//只有找到了比较符号后的字符才算找到了前面的字符
					if(hasfinedequal){
						hasfinedcharacter=true;
					}
					sql.delete(index, index+1);
					index--;
				}

				sqlstr="";
				sqlstr2="";

				if(sqlchar=='=' && sql.charAt(index-1)=='!' ){
					hasfinedequal=true;//表示已找到操作符
					index--;
					sql.delete(index, index+1);
					//找到当前index之前的第一个字符并修改index的位置
					while(sql.charAt(index)==' '){
						sql.delete(index, index+1);
						index--;
					}
					continue;
				}
				else if(sqlchar=='=' || sqlchar=='>' || sqlchar=='<'){
					hasfinedequal=true;
					sql.delete(index, index+1);
					//如果前面包括了<或者>则立即继续，因为可能当前的操作符可能是>= 或者 <=
					if(sql.charAt(index-1)=='>' || sql.charAt(index-1)=='<'){
						index--;
						sql.delete(index, index+1);
						index--;
						//可能存在 xxx <> :xxx(存在空格)
						//找到当前index之前的第一个字符并修改index的位置
						while(sql.charAt(index)==' '){
							sql.delete(index, index+1);
							index--;
						}
						continue;
					}

					index--;
				}
				//删除空格、括号
				if(sql.charAt(index)==' '|| sql.charAt(index)=='(' ){
					if(hasfinedequal && hasfinedcharacter){

						break;
					}
					//如果当前删除了(号，说明当前的？xxx 是包含在trunc(to_date(:floansdate,'yyyy-mm-dd'))里面的 可能是一个或者多个函数包含，所以需要去掉后面的)
					if(sql.charAt(index)=='(' ){
						int _tempindex=sql.indexOf(")",index);

						if(_tempindex>-1){
							sql.delete(index, _tempindex+1);
						}
					}
					if(sql.length()>index && index>2 && sql.charAt(index)!=')' && sql.charAt(index)!=' '
							&& true!=(sql.charAt(index-2)=='i' && sql.charAt(index-1)=='n')){
						sql.delete(index, index+1);
					}

					index--;
				}

				//当空格和后面的括号删除后还需在当前index之后增加一个空格，否则可能会导致后面可能会出现 and order by
				if(sql.length()>index+6&&sql.substring(index+1,index+6).equals("order")){
					sql.insert(index+1, " ");
				}
				//存在 trim(xxx)=tirm(:xxx)的情况所以当找到了操作符号后 如果前面出现了)号，则需要向前匹配到(号并删除
				l_brackets =0;
				r_brackets =1;
				if(hasfinedequal && sql.charAt(index)==')'){
					int _bracketsindex=index;
					//避免死循环
					int _tmpwhilecount=index;
					index--;
					while(_tmpwhilecount>0 && l_brackets!=r_brackets){
						if(sql.charAt(index)=='('){
							l_brackets++;
						}
						if(sql.charAt(index)==')'){
							r_brackets++;
						}
						_tmpwhilecount--;
						index--;

					}
					sql.delete(index+1, _bracketsindex+1);
					//这里删除后 可能出现 trunc(tr.FMATUREDAY)<=truncorder的情况 这样可能会导致前面的and不能被删除
					sql.insert(index+1, " ");
				}
			}

			index=index+1;
			if(index==sql.length()){
				index=sql.length()-1;
			}
			//删除前面和后面的括号
			int index_before=0;
			int index_after=0;

			index_before=finebracketIndex(sql,index,0);
			index_after=finebracketIndex(sql,index,1);

			while(index_before>-1 && index_after>-1 ){
				sql.delete(index_before, index_before+1);
				sql.delete(index_after-1, index_after);

				index_before=finebracketIndex(sql,index,0);
				index_after=finebracketIndex(sql,index,1);
			}

			//删除xxx=:xxx后还需删除前面或者后面的 or and
			int index1=finedandorIndex(sql,index,0);
			int index2=finedandorIndex(sql,index,1);
			//如果前面后面同时有则删除前面的
			if(index1>-1 && index2>-1){
				sql.delete(index1+1, index);
			}
			//如果只有后面有则删除后面的
			if(index1==-1 && index2>-1){
				sql.delete( index,index2-1);
			}
			//如果只有前面的则只删除前面的
			if(index2==-1 && index1>-1){
				sql.delete( index1+1,index);
			}

			index=sql.indexOf(key);

			if(index>-1){
				deleteSqlByKey(sql,key);
			}
		}
	}

	/**
	 * 找到前面或者后面的括号的位置
	 * @param sql
	 * @param index
	 * @param type 0前面 1后面
	 * @return
	 */
	private int finebracketIndex(StringBuffer sql,int index,int type ){
		if(type==0){
			while(index>0){
				if((sql.charAt(index) <= 'Z' && sql.charAt(index) >= 'A')
						|| (sql.charAt(index) <= 'z' && sql.charAt(index) >= 'a')
						|| (sql.charAt(index) <= '9' && sql.charAt(index) >= '0')
						|| sql.charAt(index)=='.'||sql.charAt(index)=='_'
						){
					//如果前面还能够找到非空格字符串，则说明当前位置的前面没有办法找到(
					return -1;
				}

				if( sql.charAt(index)=='('  ){
					return index;
				}
				index--;
			}

		}
		if(type==1){
			while(index<sql.length()){

				if((sql.charAt(index) <= 'Z' && sql.charAt(index) >= 'A')
						|| (sql.charAt(index) <= 'z' && sql.charAt(index) >= 'a')
						|| (sql.charAt(index) <= '9' && sql.charAt(index) >= '0')
						|| sql.charAt(index)=='.'||sql.charAt(index)=='_'
						){
					//如果前面还能够找到非空格字符串，则说明当前位置的前面没有办法找到)
					return -1;
				}

				if( sql.charAt(index)==')' ){
					return index;
				}

				index++;
			}

		}
		return -1;
	}

	/**
	 * 找到前面或者后面的 and 或者 or并返回index
	 * @param sql
	 * @param index
	 * @param type 0向前找 1向后找
	 * @return
	 */
	private int finedandorIndex(StringBuffer sql,int index,int type ){
		StringBuffer andor=new StringBuffer();
		//是否找到字符前面的空格
		boolean hasfinedspace=false;
		//是否已经找到空格前面的字母
		boolean hasfinedcharacter=false;
		if(type==0){
			while(index>0){
				if(hasfinedspace && hasfinedcharacter){
					break;
				}
				if(sql.charAt(index)=='(' ){
					//因为是向前找的，所以如果找到了(则说明前面找不到and 或者 or
					return -1;
				}
				if(sql.charAt(index)==' ' && hasfinedcharacter){
					hasfinedspace=true;
				}
				if((sql.charAt(index) <= 'Z' && sql.charAt(index) >= 'A')
						|| (sql.charAt(index) <= 'z' && sql.charAt(index) >= 'a')
						|| (sql.charAt(index) <= '9' && sql.charAt(index) >= '0')
						|| sql.charAt(index)=='.' ||sql.charAt(index)=='_'){
					hasfinedcharacter=true;
				}
				andor.insert(0, sql.charAt(index));
				index--;
			}
			String _tmpstr=andor.toString().trim().toLowerCase();
			if(_tmpstr.startsWith("and") || _tmpstr.startsWith("or")){
				return index;
			}
		}
		if(type==1){
			while(index>0 && index<sql.length()){
				if(hasfinedspace && hasfinedcharacter){
					break;
				}
				if(sql.charAt(index)==')' ){
					//因为是向后找的，所以如果找到了(则说明前面找不到and 或者 or
					return -1;
				}
				if(sql.charAt(index)==' ' && hasfinedcharacter){
					hasfinedspace=true;
				}
				if((sql.charAt(index) <= 'Z' && sql.charAt(index) >= 'A')
						|| (sql.charAt(index) <= 'z' && sql.charAt(index) >= 'a')
						|| (sql.charAt(index) <= '9' && sql.charAt(index) >= '0')
						|| sql.charAt(index)=='.'||sql.charAt(index)=='_' ){
					hasfinedcharacter=true;
				}
				andor.append( sql.charAt(index));
				index++;
			}
			String _tmpstr=andor.toString().trim().toLowerCase();
			if(_tmpstr.endsWith("and") || _tmpstr.endsWith("or") ){
				return index;
			}
		}
		return -1;
	}

	public static void main(String[] args) {
		String sql = " SELECT t.*,(SELECT COUNT(1) FROM kd_organization WHERE ORG_PARENT_ID = t.org_id) childrenOrg," +
				"        (SELECT ORG_NAME FROM kd_organization WHERE org_id=t.ORG_PARENT_ID) ORGZ_PARENTNAME FROM kd_organization t" +
				" WHERE  1=1 and  t.is_delete = :is_delete and is_delete=:isDelete ";
		QueryParam q = new QueryParam();

		SysMenuDTO dto = new SysMenuDTO();
		dto.setIsDelete(1);


		Map<String,Object> param = new HashMap<String,Object>();
		/*
		param.put("meid","wangw");
		param.put("age",false);
		param.put("age1",10L);
		param.put("age2",10D);
		param.put("age3",10f);
		param.put("Date",new Date());
		*/

		q.setSql(sql);
		//q.setParams(param);
		q.setParamObject(dto);
		//q.valueSql(sql,param);
		try {
			System.out.println(q.getSql());
		}catch (Exception e){

		}

	}
}
